import axios from 'axios'
import { getToken } from '@/utils/auth'
import panelGroup from '@/views/dashboard/admin/components/PanelGroup'
import JSZip from 'jszip'

export function treeDataTranslate(data, id = 'id', pid = 'parentId', pidValue) {
  let res = []
  for (let i = 0; i < data.length; i++) {
    if (pidValue) {
      if (data[i][pid] === pidValue) {
        data[i].children = treeDataTranslate(data, id, pid, data[i][id])
        res.push(data[i])
      }
    } else {
      if (!data[i][pid]) {
        res.push(data[i])
        data[i].children = treeDataTranslate(data, id, pid, data[i][id])
      }
    }
  }
  res.sort((a, b) => a[id] - b[id])

  // 对每个子节点的 children 进行排序
  res.forEach(node => {
    if (node.children && node.children.length > 0) {
      node.children.sort((a, b) => a[id] - b[id])
    }
  })
  return res
}

// let temp
// for (let i = 0; i < data.length; i++) {
//   if (!data[i][pid]) {
//     res.push(data[i])
//   }
//   for (let k = 0; k < data.length; k++) {
//     if (data[i][id] === data[k][pid]) {
//       temp = data[i].children || []
//       temp.push(data[k])
//       data[i].children = temp
//     }
//   }
//   // return res
// }

// 导出
export function downloadExcel(res) {
  console.log(res)
  // 从响应头中获取文件名
  const contentDisposition = res.headers['content-disposition']
  const fileName = decodeURI(
    contentDisposition
      .split(';')[1]
      .split('filename=')[1]
      .trim()
  )

  // 创建 Blob 对象
  const blob = new Blob([res.data], { type: 'application/x-xls' })

  // 兼容 IE 浏览器
  if (window.navigator.msSaveBlob) {
    try {
      window.navigator.msSaveBlob(blob, fileName)
    } catch (e) {
      console.error('IE 下载失败：', e)
    }
  } else {
    // 创建下载链接
    const downloadElement = document.createElement('a')
    const href = window.URL.createObjectURL(blob)
    downloadElement.href = href
    downloadElement.download = fileName
    document.body.appendChild(downloadElement)
    downloadElement.click() // 触发下载
    document.body.removeChild(downloadElement) // 移除链接
    window.URL.revokeObjectURL(href) // 释放 URL 对象
  }
}

// 导入

/**
 * 导入 Excel 文件
 * @param {File} file - 选择的文件
 * @param {string} action - 上传接口地址
 * @param {number} maxSize - 文件大小限制（单位：MB）
 * @returns {Promise} - 返回解析后的数据
 */
export function importExcel(file, action, maxSize = 10) {
  return new Promise((resolve, reject) => {
    // 校验文件类型
    const isExcel =
      file.type ===
      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' ||
      file.type === 'application/vnd.ms-excel'

    if (!isExcel) {
      reject(new Error('只能上传 Excel 文件！'))
      return
    }

    // 校验文件大小
    const isLtMaxSize = file.size / 1024 / 1024 < maxSize
    if (!isLtMaxSize) {
      reject(new Error(`文件大小不能超过 ${maxSize}MB！`))
      return
    }

    // 创建 FormData
    const formData = new FormData()
    formData.append('file', file)

    // 调用后端接口上传文件
    /*axios
      .post(action, formData, {
        headers: {
          'Content-Type': 'multipart/form-data',
        },
      })
      .then(response => {
        if (response.data.code === 200) {
          resolve(response.data.data); // 返回解析后的数据
        } else {
          reject(new Error(response.data.message || '文件上传失败！'));
        }
      })
      .catch(error => {
        reject(error);
      });*/
  })
}

/**
 * 获取当月的第一天到当天的日期范围 格式化日期为 YYYY-MM-DD
 * @returns {Object} 包含开始日期和结束日期的对象
 */
export const getMonthRange = () => {
  const date = new Date() // 当前日期
  const startOfMonth = new Date(date.getFullYear(), date.getMonth(), 1) // 当月第一天
  const endOfMonth = new Date() // 当天日期

  const formatDate = (date) => {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0') // 月份补零
    const day = String(date.getDate()).padStart(2, '0') // 日期补零
    return `${year}-${month}-${day}`
  }

  return {
    startOfMonth: formatDate(startOfMonth), // 当月第一天
    endOfMonth: formatDate(endOfMonth)         // 当天日期
  }
}

export function dateFormat(fmt, date) { //author: meizz
  if (date instanceof Date) {
    var o = {
      'M+': date.getMonth() + 1, //月份
      'd+': date.getDate(), //日
      'h+': date.getHours(), //小时
      'm+': date.getMinutes(), //分
      's+': date.getSeconds(), //秒
      'q+': Math.floor((date.getMonth() + 3) / 3), //季度
      'S': date.getMilliseconds() //毫秒
    }
    if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
    for (var k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (('00' + o[k]).substr(('' + o[k]).length)))
    }
    return fmt
  }
  return date
}

//数字脱敏
export function maskString(str, visibleDigits = 4) {
  // 获取字符串的长度
  const length = str.length

  // 如果字符串长度小于等于可见位数，直接返回原字符串
  if (length <= visibleDigits) {
    return str
  }

  // 计算需要隐藏的部分的长度
  const hiddenLength = length - visibleDigits

  // 用星号替换隐藏部分
  // const hiddenPart = '*'.repeat(hiddenLength);
  const hiddenPart = '***'
  // 获取字符串的后几位
  const visiblePart = str.slice(-visibleDigits)

  // 返回脱敏后的结果
  return hiddenPart + visiblePart
}

/**
 * 获取当前日期和半年前的日期，格式为 yyyy-MM-dd HH:mm:ss
 * @returns {Object} 包含当前日期和半年前日期的对象
 */
export function getDateRange() {
  const now = new Date()
  const currentDate = formatDate(now)

  const sixMonthsAgo = new Date(now)
  sixMonthsAgo.setMonth(now.getMonth() - 6)
  const sixMonthsAgoDate = formatDate(sixMonthsAgo)

  return {
    currentDate,
    sixMonthsAgoDate
  }
}

/**
 * 格式化日期为 yyyy-MM-dd HH:mm:ss 格式
 * @param {Date} date - 要格式化的日期
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date) {
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hours = String(date.getHours()).padStart(2, '0')
  const minutes = String(date.getMinutes()).padStart(2, '0')
  const seconds = String(date.getSeconds()).padStart(2, '0')

  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`
}

//获取日期   yyyy-MM-dd
export function fun_date(aa) {
  let date1 = new Date()
  let date2 = new Date(date1)
  date2.setDate(date1.getDate() + aa)
  let time2 = date2.getFullYear() + '-' + ('0' + (date2.getMonth() + 1)).substr(-2) + '-' + ('0' + date2.getDate()).substr(-2)
  return time2
}

//获取日期   yyyy-MM-dd HH:mm:ss
export function fun_date1() {
  const now = new Date()
  const currentDate = formatDate(now)
  return currentDate
}

/**
 * 获取当前日期和当前日期七天前的日期时间，格式为 yyyy-MM-dd HH:mm:ss
 * @returns {string} 格式化后的日期字符串
 */
export function getSevenDaysAgo() {
  const now = new Date()
  const currentDate = formatDate(now)
  const sevenDaysAgo = new Date(now)
  sevenDaysAgo.setDate(now.getDate() - 7)
  const sevenDaysAgoDate = formatDate(sevenDaysAgo)
  return {
    currentDate,
    sevenDaysAgoDate
  }
}

/**
 * 获取当前月的第一天和当前日期，格式为 yyyy-MM-dd
 * @returns {Object} 包含第一天和当前日期的对象
 */
export function getFirstDayAndCurrentDay() {
  const now = new Date()
  const firstDay = new Date(now.getFullYear(), now.getMonth(), 1)
  const formatDate = (date) => {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0')
    const day = String(date.getDate()).padStart(2, '0')
    return `${year}-${month}-${day}`
  }
  return {
    firstDay: formatDate(firstDay),
    currentDay: formatDate(now)
  }
}

/**
 * 根据给定的开始日期和结束日期，将日期范围拆分为以月为单位的日期范围数组
 * @param {string} startStr - 开始日期，格式为 'YYYY-MM-DD'
 * @param {string} endStr - 结束日期，格式为 'YYYY-MM-DD'
 * @returns {Array<Array<string>>} - 包含每个月日期范围的数组，每个子数组包含开始日期和结束日期，格式为 'YYYY-MM-DD'
 */
export function getMonthlyRanges(startStr, endStr) {
  // 解析日期为UTC Date对象
  const startDate = parseDate(startStr)
  const endDate = parseDate(endStr)

  if (startDate > endDate) return []

  const ranges = []
  const startYear = startDate.getUTCFullYear()
  const startMonth = startDate.getUTCMonth()
  const endYear = endDate.getUTCFullYear()
  const endMonth = endDate.getUTCMonth()

  let currentYear = startYear
  let currentMonth = startMonth

  while (currentYear < endYear || (currentYear === endYear && currentMonth <= endMonth)) {
    const isStartMonth = currentYear === startYear && currentMonth === startMonth
    const isEndMonth = currentYear === endYear && currentMonth === endMonth

    let rangeStart, rangeEnd

    if (isStartMonth && isEndMonth) {
      // 开始和结束在同一个月
      rangeStart = startDate
      rangeEnd = endDate
    } else if (isStartMonth) {
      // 处理起始月份
      rangeStart = startDate
      // 计算该月最后一天
      rangeEnd = new Date(Date.UTC(currentYear, currentMonth + 1, 0))
    } else if (isEndMonth) {
      // 处理结束月份
      rangeStart = new Date(Date.UTC(currentYear, currentMonth, 1))
      rangeEnd = endDate
    } else {
      // 处理中间月份
      rangeStart = new Date(Date.UTC(currentYear, currentMonth, 1))
      rangeEnd = new Date(Date.UTC(currentYear, currentMonth + 1, 0))
    }

    // 格式化并添加日期范围
    ranges.push([
      newFormatDate(rangeStart),
      newFormatDate(rangeEnd)
    ])

    // 前进到下一月
    currentMonth++
    if (currentMonth > 11) {
      currentYear++
      currentMonth = 0
    }
  }

  return ranges
}

// 解析日期字符串为UTC Date对象
function parseDate(dateStr) {
  const [year, month, day] = dateStr.split('-').map(Number)
  return new Date(Date.UTC(year, month - 1, day))
}

// 格式化Date对象为'YYYY-MM-DD'字符串
export function newFormatDate(date) {
  const year = date.getUTCFullYear()
  const month = String(date.getUTCMonth() + 1).padStart(2, '0')
  const day = String(date.getUTCDate()).padStart(2, '0')
  return `${year}-${month}-${day}`
}

// 获取本周一到当前日期的时间，格式为 yyyy-MM-dd
export function getWeekDate() {
  const now = new Date()
  const dayOfWeek = now.getDay() // 获取当前日期是周几（0-6，0表示周日）

  // 获取本周周一的日期
  let monday
  if (dayOfWeek === 0) {
    // 如果今天是周日，那么本周周一的日期是今天的前一天
    monday = new Date(now)
    monday.setDate(now.getDate() - 6)
  } else {
    // 否则，本周周一的日期是今天的前 (dayOfWeek - 1) 天
    monday = new Date(now)
    monday.setDate(now.getDate() - dayOfWeek + 1)
  }

  // 格式化日期
  const formatDate = (date) => {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0')
    const day = String(date.getDate()).padStart(2, '0')
    return `${year}-${month}-${day}`
  }

  return {
    startOfWeek: formatDate(monday), // 本周周一的日期
    endOfWeek: formatDate(now)       // 当前天的日期
  }
}

/**
 * 读取医保卡信息
 * @param {string} McardType 读卡类型编码 00-四合一, 01-电子凭证, 02-身份证, 03-社保卡
 * @param {string} businessType 用码业务类型 01医院: 01101挂号, 01103入院登记, 01301结算
 * @param {string} CardNo 手动输入号码
 * @returns {Promise<Object>} 返回医保卡信息
 */
export async function readCard(McardType, businessType, CardNo, info) {
  try {
    // 手动输入卡串
    if (CardNo) {
      return {
        mdtrt_cert_type: '02',  // 就诊凭证类型 Y 02身份证
        mdtrt_cert_no: CardNo   // 就诊凭证编号 Y 身份证号码
      }
    }

    if (!businessType) {
      businessType = '01101' // 默认挂号
    }

    let cardInputJSON
    let read_way = '1' // 读卡类型 1-社保卡; 2-医保电子凭证；3-身份证号码

    if (McardType === '03') { // 身份证
      read_way = '3'
    } else if (McardType === '01') { // 电子凭证
      read_way = '2'
    }

    // 调用读卡动态库
    console.log(read_way, businessType)
    cardInputJSON = await readCardDll(read_way, businessType, info)
    // console.log(await readCardDll(read_way, businessType))

    return cardInputJSON
  } catch (error) {
    console.error('读卡失败:', error)
    throw error
  }
}

/**
 * 调用读卡动态库
 * @param {string} read_way 读卡类型
 * @param {string} businessType 业务类型
 * @returns {Promise<Object>} 返回读卡结果
 */
async function readCardDll(read_way, businessType, dataInfo) {
  /* const pInData = {
    trns_type: '1',
    read_way: '1',
    medins_no: 'H14022301089',
    fixmedins_name: '广灵县中医医院',
    businessType: '01301',
    opter: '024',
    opter_name: '宋受广',
    opter_type: '1',
    dept_no: 'zy06',
    dept_name: '儿科门诊',
    mdtrtarea_admvs: '140223',
    dev_no: '',
    dev_safe_info: '',
    cainfo: '',
    signtype: '',
    infver: 'V1.0',
    inf_time: 1747183261515,
    sign_no: '',
    begntime: ''
  } */
  const pInData = {
    trns_type: dataInfo.trns_type,
    read_way: read_way,
    medins_no: dataInfo.medins_no,
    fixmedins_name: dataInfo.fixmedins_name,
    businessType: businessType,
    opter: dataInfo.opter,
    opter_name: dataInfo.opter_name,
    opter_type: dataInfo.opter_type,
    dept_no: dataInfo.dept_no,
    dept_name: dataInfo.dept_name,
    mdtrtarea_admvs: dataInfo.mdtrtarea_admvs,
    dev_no: dataInfo.dev_no,
    dev_safe_info: dataInfo.dev_safe_info,
    cainfo: dataInfo.cainfo,
    signtype: dataInfo.signtype,
    infver: dataInfo.infver,
    inf_time: dataInfo.inf_time,
    sign_no: '',
    begntime: dataInfo.begntime
  }

  let resultData

  // 调用读卡服务
  const pOutData = await callReadCardService(pInData)
  console.log(pOutData)
  console.log(pOutData.includes('Error'))
  console.log(pOutData[3])
  // 解析返回结果
  if (pOutData != '' && !pOutData.includes('Error') && pOutData[2] != '-1') {
    const pOutDataJSON = pOutData.map((item, index) => {
      if (typeof item === 'string' && item !== '') {
        // try {
        // 先清理多层转义
        const cleaned = cleanEscape(item)
        // 再解析为 JSON
        console.log(cleaned)
        return JSON.parse(cleaned)
        // } catch (e) {
        //   console.error('解析失败:', e)
        //   return item // 返回原始字符串用于调试
        // }
      }
      return item // 非字符串元素直接返回
    })
    console.log('pOutDataJSON:', pOutDataJSON[1].infcode)
    if (pOutDataJSON && pOutDataJSON[1] && pOutDataJSON[1].infcode !== 0) {
      throw new Error('读卡错误：' + pOutDataJSON.err_msg)
    }
    resultData = pOutDataJSON[1].output
    if (read_way === '3' && resultData) {
      resultData.mdtrt_cert_type = '02'
      const baseinfo = resultData.baseinfo
      resultData.mdtrt_cert_no = baseinfo.certno
    }
  } else {
    resultData = pOutData[3]
  }
  console.log(resultData)
  return resultData
}

/**
 * 调用读卡服务
 * @param {Object} input 输入参数
 * @returns {Promise<string>} 返回读卡结果
 */
async function callReadCardService(input) {
  const sendData = JSON.stringify([input, '', '0', ''])
  const returnValue = await sendMessage('sxnewsi', 'yh_call', sendData)
  console.log('returnValue:', returnValue)
  return returnValue
}

/**
 * 发送消息
 * @param {string} siname 服务名
 * @param {string} funcname 方法名
 * @param {string} serverData 发送的数据
 * @returns {Promise<string>} 返回结果
 */
async function sendMessage(siname, funcname, serverData) {
  const url = 'http://localhost:9511/service/'
  /*  const response = await fetch(url, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
       'eventType': 'SI',
       'siname': siname,
       'funcname': funcname,
       'timeout': '30000'
     },
     body: serverData
   })

   if (response.ok) {
     return await response.text()
   } else {
     throw new Error('医保接口调用失败：' + response.statusText)
   } */
  // let result = ''
  console.log('进来了')
  let result = await axios({
    method: 'post', // 请求方法
    url: 'http://localhost:9511/service/', // 请求URL
    data: serverData, // 请求体数据
    headers: { // 请求头
      'Content-Type': 'application/json', // 设置内容类型为JSON
      'eventType': 'SI', // 事件类型
      'siname': siname, // 医保ID
      'funcname': funcname, // 方法名
      'timeout': 30000 // 超时时间
    },
    timeout: 30000, // 超时时间（毫秒）
    responseType: 'json' // 响应数据类型为JSON
  }).then(async response => { // 请求成功
    return response.data // 获取响应数据
    console.log(result)
  }).catch(async error => { // 请求失败
    return error
    console.log(error)
    result = '-1%%' + error.message + '，请检查本机客户端服务是否开启！' // 错误处理
  })
  console.log(result)
  return result
}

// 清洗函数（处理多层转义）
function cleanEscape(str) {
  return str
    .replace(/\\"/g, '"')    // 处理转义双引号
    .replace(/\\/g, '\\')  // 处理多余反斜杠
}
